#ifndef HJX_H_INCLUDED
#define HJX_H_INCLUDED



#endif // HJX_H_INCLUDED
namespace hjx
{
    template<class T>
    struct _list_node
    {
        _list_node*next;
        _list_node*prev;
        T _date;
        _list_node(const T&x=T())
        :_date(x)
        ,next(nullptr)
        ,prev(nullptr)
        {

        }
    };
    template<class T,class Ref,class Ptr>
    struct _list_iterator
    {
        typedef _list_node<T> node;
        typedef _list_iterator<T,Ref,Ptr> Self;
        node*_node;
        _list_iterator(node*n)
        :_node(n)
        {

        }
        //*it
        Ref operator*()
        {
            return _node->_date;
        }
        //++it
        Self& operator++()
        {
            _node=_node->next;
            return *this;
        }
        //it++
        Self operator++(int)
        {
            Self tmp(*this);
            _node=_node->next;
            return tmp;
        }
        //--it
        Self& operator--()
        {
            _node=_node->prev;
            return *this;
        }
        Self operator--(int)
        {
            Self tmp(*this);
            _node=_node->prev;
            return tmp;
        }
        //it!=end()
        bool operator!=(const Self&it)
        {
            return _node!=it._node;
        }
        bool operator==(const Self&it)
        {
            return _node==it._node;
        }
        Ptr operator->()
        {
            return &(_node->_date);
        }
    };
    template<class T>
    class list
    {
        typedef _list_node<T> node;
    public:
        typedef _list_iterator<T,T&,T*> iterator;
        typedef _list_iterator<T,const T&,const T*> const_iterator;
        //带头双向循环链表
        list()
        {
            _head=new node;
            _head->next=_head;
            _head->prev=_head;
        }
        //拷贝构造
        list(const list<int> &lt)
        {
            _head=new node;
            _head->next=_head;
            _head->prev=_head;
            const_iterator it=lt.begin();
            while(it!=lt.end())
            {
                push_back(*it);
                it++;
            }

        }
        //赋值
//        list<T> operator=(const list<T> &l)
//        {
//            //传统写法
//            clear();
//            const_iterator it=l.begin();
//            while(it!=l.end())
//            {
//                push_back(*it);
//                it++;
//            }
//             return *this;
//        }
         //现代写法
         list<T> operator=(list<T> l)
         {
             swap(_head,l._head);
             return *this;
         }
        ~list()
        {
            clear();
            delete _head;
            _head=nullptr;
        }
        void clear()
        {
            iterator it=begin();
            while(it!=end())
            {
                erase(it++);
            }
        }
        const_iterator begin()const
        {
            return const_iterator(_head->next);
        }
        const_iterator end()const
        {
            return const_iterator(_head);
        }
        iterator begin()
        {
            return iterator(_head->next);
        }
        iterator end()
        {
            return iterator(_head);
        }
        void push_back(const T&x)
        {
//            node*tail=_head->prev;
//            node*newnode=new node(x);
//            tail->next=newnode;
//            newnode->prev=tail;
//            _head->prev=newnode;
//            newnode->next=_head;
              insert(end(),x);

        }
        void insert(iterator pos,const T&x)
        {
            node*cur=pos._node;
            node*newnode=new node(x);
            node*prev=cur->prev;
            prev->next=newnode;
            newnode->prev=prev;
            newnode->next=cur;
            cur->prev=newnode;
        }
        void erase(iterator pos)
        {
            if(pos!=end())//哨兵位的头节点不能删
            {
            node*cur=pos._node;
            node*prev=cur->prev;
            node*next=cur->next;
            delete cur;
            prev->next=next;
            next->prev=prev;
            }

        }
        void pop_back()//位删
        {
            erase(iterator(_head->prev));
            //erase(--end())//方法二
        }
        void pop_front()
        {
            erase(iterator(begin()));
        }
    private:
        node*_head;
    };
    struct Date
    {
        int _year=1;
        int _month=0;
        int _day=0;

    };
    void text1()
    {
        list<int> l;
        l.push_back(1);
        l.push_back(2);
        l.push_back(3);
        list<int>::iterator it=l.begin();
        while(it!=l.end())
        {
            cout<<*it;
            ++it;
        }
        cout<<endl;
    }
    void text2()
    {
        list<Date> l;
        l.push_back(Date());
        l.push_back(Date());
        list<Date>::iterator it=l.begin();
        while(it!=l.end())
        {
            cout<<it->_year<<" "<<it->_month<<" "<<it->_day<<endl;
            ++it;
        }
    }
    void print_list(const list<int>&lt)
    {
        list<int>::const_iterator it=lt.begin();
        while(it!=lt.end())
        {
//            *it=1;
            cout<<*it;
            it++;
        }
    }
    void text3()
    {
        list<int> lt;
        lt.push_back(1);
        lt.push_back(2);
        lt.push_back(3);
        print_list(lt);
    }
    void text4()
    {
        list<int> lt;
        lt.push_back(1);
        lt.push_back(2);
        lt.push_back(3);
        list<int> lt2(lt);//拷贝构造
        list<int> lt3;
        lt3.push_back(10);
        lt3.push_back(20);
        lt=lt3;
        print_list(lt3);
    }
}
